package com.shenzhenai.composebasic.components

import android.util.Log
import androidx.compose.foundation.layout.Column
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.tooling.preview.Preview
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.compose.LifecycleEventEffect
import androidx.lifecycle.compose.LocalLifecycleOwner

/**
 * @author huangzehui
 * @date 17/9/2025 上午1:22 周三
 * @description
 *
 * 生命周期（其实就是可组合函数中的副作用）
 * https://www.bilibili.com/video/BV14u411B7qM/?vd_source=e07cc8cc94eb22bd76722071b03cd199&spm_id_from=333.788.videopod.sections
 */

@Composable
fun LifecycleSample() {

    var count by remember {
        mutableStateOf(0)
    }

    /**
     * 开启一个副作用(Compose  函数启动的时候)
     *
     * key1 - 就是需要监听的对象，就是当key1变量变化的时候，LaunchedEffect 的block就会回调
     *
     * 如果传递的是 Unit 或其他固定的值，那么这个block只会创建一次（Composable 启动的时候，执行一次），如果是监听某个状态变化 ，那么状态变化就回调
     */
    LaunchedEffect(key1 = count, block = {
        Log.e("young_test909090d", "LaunchedEffect")
    })

    Log.e("young_test909090d", "LaunchedEffect  1111")

    // 获取生命周期拥有者
    val lifecycleOwner = LocalLifecycleOwner.current

    /**
     * 监听指定的生命周期
     *
     * event ： 需要监听的生命周期事件名称
     */
    LifecycleEventEffect(event = Lifecycle.Event.ON_RESUME) {
        Log.e("young_test909090d", "onResume  1111")
    }

    DisposableEffect(lifecycleOwner) {

        // 生命周期事件回调
        val lifecycleEventObserver = LifecycleEventObserver { _, event ->
            when(event){
                Lifecycle.Event.ON_RESUME->{
                    Log.e("young_test909090d", "LifecycleEventObserver onResume  1111")
                }
                Lifecycle.Event.ON_PAUSE->{
                    Log.e("young_test909090d", "LifecycleEventObserver onPause  1111")
                }
                else->{}
            }
        }

        lifecycleOwner.lifecycle.addObserver(lifecycleEventObserver)

        onDispose {
            // 取消生命周期注册
            lifecycleOwner.lifecycle.removeObserver(lifecycleEventObserver)
        }
    }

    Column {
        Text(text = "Text${count}")
        Button(onClick = {
            count++
        }) {
            Text(text = "Button")
        }
        if (count == 3) {
            SubScreen(count)
        }
    }
}


@Composable
fun SubScreen(count: Int) {
    /**
     * 开启一个关闭的副作用(销毁方法，Compose 函数销毁的时候)
     *
     * key1 - 就是需要监听的对象，就是当key1变量变化的时候，LaunchedEffect 的block就会回调
     *
     * 如果传递的是 Unit 或其他固定的值，那么这个block只会创建一次（Composable 启动的时候，执行一次），如果是监听某个状态变化 ，那么状态变化就回调
     */
    DisposableEffect(Unit) {
        Log.e("young_test909090d", "DisposableEffect")
        onDispose {
            // Compose 函数销毁的时候调用
            Log.e("young_test909090d", "DisposableEffect:onDispose")
        }
    }
    Text(text = "SubScreen = ${count}")
}

@Preview
@Composable
fun LifecycleSamplePreview() {
    LifecycleSample()
}